home *** CD-ROM | disk | FTP | other *** search
/ Gekikoh Dennoh Club 1 / Gekikoh Dennoh Club Vol. 1 (Japan).7z / Gekikoh Dennoh Club Vol. 1 (Japan) (Track 1).bin / tools / dcview / src / cutsub.c next >
Text File  |  1997-03-05  |  13KB  |  457 lines
  1. #include <sxdef2.h>
  2. #include <stdio.h>
  3. #include <iocslib.h>
  4. #include <stdlib.h>
  5.  
  6. #include <event.h>        /* イベントマンを利用するときに必要    */
  7. #include <sxmemory.h>        /* メモリマンを利用するときに必要    */
  8. #include <sxgraph.h>        /* グラフ系マネージャを利用するときに必要 */
  9. #include <window.h>        /* ウィンドウマンを利用するときに必要    */
  10. #include <dialog.h>        /* ダイアログマンを利用するときに必要    */
  11. #include <task.h>        /* タスクマンを利用するときに必要    */
  12. #include "DC.h"
  13.  
  14. #define    BUF_X        128
  15. #define    BUF_Y        16
  16. #define    CUTMODE        1
  17. #define    TITLEMODE    2
  18.  
  19. typedef    unsigned char    BYTE2;
  20.  
  21. typedef    BYTE2    LINEBUF[ BUF_X ];
  22.  
  23. typedef    struct    {
  24.         short    dx, dy;
  25.         LINEBUF    buffer[ BUF_Y ];
  26.     } TEXTBUF;
  27.  
  28. typedef    BYTE2    CONDBUF[ 1 + BUF_X/8 + BUF_X ];
  29.  
  30. void    cutPrint();
  31. int    cutType();
  32. int    cutType2();    
  33.  
  34. int cut(ComVal *pcv, char *fileName)
  35. {
  36.     unsigned char    headder[49];
  37.     FILE    *cutFile;
  38.     int    plane = 3;
  39.     int    x0, y0, x1, y1;
  40.     char ext[5];
  41.     char **dmy1;
  42.     char *pt;
  43.     int fileLen;
  44.  
  45.     pcv->rc.d.left = 0;        /* FillImg レクタングル        */
  46.     pcv->rc.d.top = 0;
  47.     pcv->rc.d.bottom = 16;
  48.  
  49.     if (( cutFile = fopen( fileName, "rb")) == NULL ) {
  50.         EMDeCross();
  51.         DMError(D_RED | D_CONFIRM, "cutsub.c\rファイルがオープンできません！" );
  52.         fclose(cutFile);
  53.         EMEnCross();
  54.         return(0);
  55.     } else {
  56.         fseek(cutFile, 0L, SEEK_END);
  57.         fileLen = ftell(cutFile);    /* ファイルサイズを求める    */
  58.         fseek(cutFile, 0L, SEEK_SET);
  59.  
  60.         dmy1 = NULL;
  61.         dmy1 = MMChHdlNew(fileLen+1);
  62.  
  63.         if (dmy1 == NULL) {        /* メモリが確保できる？        */
  64.             DMError(D_CONFIRM | D_RED, "メモリが確保できません!");
  65.             fclose(cutFile);
  66.             return(0);
  67.         }
  68.         MMHdlDispose(dmy1);
  69.         pcv->cutHdl = MMChHdlNew(fileLen+1);
  70.         MMHdlLock(pcv->cutHdl);
  71.         fread(*(pcv->cutHdl), sizeof(char), (size_t) (fileLen), cutFile);
  72.         fclose(cutFile);
  73.  
  74.         pcv->cutPt = *(pcv->cutHdl);
  75.         pt = pcv->cutPt;
  76.         *(pt+fileLen) = 1;
  77.  
  78.         read_cut(pcv, headder, 48 );
  79.         headder[48] = '\0';    /* ★ごみ防止 (89/04/14) */
  80.         if( headder[0] == 0 ) {
  81.             if (cutType2(pcv, plane)) {    /* Title.sys */
  82.                 MMHdlUnlock(pcv->cutHdl);
  83.                 MMHdlDispose(pcv->cutHdl);
  84.                 return(0);
  85.             }
  86.         } else if( strncmp( headder, "CUT_V", 5 ) == 0 ) {
  87.             if(!cutType(pcv, plane)) {    /* cut */
  88.                 MMHdlUnlock(pcv->cutHdl);
  89.                 MMHdlDispose(pcv->cutHdl);
  90.                 return(0);
  91.             }
  92.         } else {
  93.             EMDeCross();
  94.             DMError(D_RED | D_CONFIRM, "データが異常です！" );
  95.             MMHdlUnlock(pcv->cutHdl);
  96.             MMHdlDispose(pcv->cutHdl);
  97.             EMEnCross();
  98.             return(0);
  99.         }
  100.     }
  101.     MMHdlUnlock(pcv->cutHdl);
  102.     MMHdlDispose(pcv->cutHdl);
  103.     pcv->cutNo[pcv->depth]++;
  104.     return(1);
  105. }
  106.  
  107.  
  108. int    cutType(pcv, plane)    /* ★カットファイル表示 */
  109.     ComVal *pcv;
  110.     int    plane;
  111. {
  112.     short    dx, dy;
  113.     int    size, y;
  114.     TEXTBUF oneRegion;
  115.     CONDBUF    cond1, cond2;
  116.     BYTE2    *buffer;
  117.     int cut_no_buff;
  118.  
  119.     read_cut(pcv, &oneRegion, 4 );
  120.     dx = oneRegion.dx;
  121.     dy = oneRegion.dy;
  122.     pcv->rc.d.right = dx;
  123.     pcv->ymax = dy;
  124.     pcv->size = dx * dy;
  125.     pcv->x_size = dx;
  126.     pcv->y_size = dy;
  127.  
  128.     cut_no_buff = pcv->cutNo[pcv->depth];
  129.     pcv->cutNo[pcv->depth] = 0;
  130.     if (offgraph(pcv) != TRUE)
  131.         return(FALSE);
  132.  
  133.     pcv->cutNo[pcv->depth] = cut_no_buff;
  134.     pcv->x_size = (dx * pcv->fontS[pcv->font]) / 16;
  135.     pcv->y_size = (dy * pcv->fontS[pcv->font]) / 16;
  136.  
  137.     if (offgraph(pcv) != TRUE)
  138.         return(FALSE);
  139.  
  140.     GMLockBits(pcv->bitsH[0][pcv->depth]);    /* オフライングラフのビッツをロック    */
  141.     GMLockBits(pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth]);    /* オフライングラフのビッツをロック    */
  142.     GMSetGraph(&pcv->offgraph[0][pcv->depth]);     /* 描画をオフライン画面に対して行う     */
  143.     pcv->offgraph[0][pcv->depth].bmap = &(*pcv->bitsH[0][pcv->depth])->bmap;
  144.     GMAPage(G_ALLPAGE);            /* カレントグラフの初期設定    */
  145.     GMBackColor(G_BLACK);
  146.     GMForeColor(G_WHITE);
  147.  
  148.     size = ((( dx - 1 ) >> 3 ) + 1 );
  149.     y = 0;
  150.     buffer = &oneRegion.buffer;
  151.     expand2( buffer, 0, cond2 );
  152.     for( ; dy; dy-- ) {
  153.         read_cut(pcv, cond1, 1 );
  154.         read_cut(pcv, cond1+1, *cond1-1 );
  155.         expand1( cond2, size, cond1 );
  156.         expand2( buffer, size, cond2 );
  157.         buffer += size;
  158.         if( ++y == BUF_Y ) {
  159.             y = 0;
  160.             buffer = &oneRegion.buffer;
  161.             cutPrint(pcv, buffer );
  162.         }
  163.     }
  164.     if ( y != 0 ) {
  165.         buffer = &oneRegion.buffer;
  166.         cutPrint(pcv, buffer );
  167.     }
  168.     GMSetGraph(&pcv->offgraph[pcv->cutNo[pcv->depth]][pcv->depth]); /* 描画をオフライン画面に対して行う     */
  169.     pcv->offgraph[pcv->cutNo[pcv->depth]][pcv->depth].bmap = &(*pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth])->bmap;
  170.     GMCopy(&(*pcv->bitsH[0][pcv->depth])->bmap, &(*pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth])->bmap,
  171.         &pcv->offgraph[0][pcv->depth].rect, &pcv->offgraph[pcv->cutNo[pcv->depth]][pcv->depth].rect,
  172.             G_PSET, NULL);
  173.     GMUnlockBits(pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth]); /* オフライングラフのビッツをアンロック    */
  174.     GMUnlockBits(pcv->bitsH[0][pcv->depth]);      /* オフライングラフのビッツをアンロック    */
  175.     if (pcv->bitsH[0][pcv->depth] != NULL)
  176.         /* オフグラフ用のビッツハンドルを廃棄する */
  177.         GMDisposeBits(pcv->bitsH[0][pcv->depth]);
  178.  
  179.     /* オフライングラフが作成されていたら */
  180.     if (pcv->offgraphOK[0][pcv->depth]) {
  181.         /* ビットマップポインタだけヌルにして */
  182.         pcv->offgraph[0][pcv->depth].bmap = NULL;
  183.         /* グラフをクローズする */
  184.         GMCloseGraph(&pcv->offgraph[0][pcv->depth]);
  185.     }
  186.     return(TRUE);
  187. }
  188.  
  189. #define    H2_MAX    20
  190.  
  191. int    cutType2(pcv, plane)    /* ★TITLE.SYSフォーマットデータ表示 */
  192.     ComVal *pcv;
  193.     int    plane;
  194. {
  195.     short    dx, dy;
  196.     int    size, y, amari;
  197.     TEXTBUF oneRegion;
  198.     BYTE2    *buffer;
  199.     unsigned char    headder2[H2_MAX];
  200.     int cut_no_buff;
  201.  
  202.     read_cut(pcv, headder2, H2_MAX );
  203.     dx = headder2[H2_MAX - 4];
  204.     dx = (dx << 8) + headder2[H2_MAX - 3];
  205.     dy = headder2[H2_MAX - 2];
  206.     dy = (dy << 8) + headder2[H2_MAX - 1];
  207.     if((dx <= 0) || (dy <= 0) || (dx > 1024) || (dy > 1024)) {
  208.         EMDeCross();
  209.         DMError(D_RED | D_CONFIRM, "cutsub.c\rデータが異常です！" );
  210.         EMEnCross();
  211.         return(1);
  212.     }
  213.     oneRegion.dx = dx;
  214.     oneRegion.dy = BUF_Y;
  215.     pcv->rc.d.right = dx;
  216.     pcv->ymax = dy;
  217.     pcv->size = dx * dy;
  218.     pcv->x_size = dx;
  219.     pcv->y_size = dy;
  220.  
  221.     cut_no_buff = pcv->cutNo[pcv->depth];
  222.     pcv->cutNo[pcv->depth] = 0;
  223.     if (offgraph(pcv) != TRUE)
  224.         return(FALSE);
  225.  
  226.     pcv->cutNo[pcv->depth] = cut_no_buff;
  227.     pcv->x_size = (dx * pcv->fontS[pcv->font]) / 16;
  228.     pcv->y_size = (dy * pcv->fontS[pcv->font]) / 16;
  229.  
  230.     if (offgraph(pcv) != TRUE)
  231.         return;
  232.  
  233.     GMLockBits(pcv->bitsH[0][pcv->depth]);        /* オフライングラフのビッツをロック    */
  234.     GMLockBits(pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth]);    /* オフライングラフのビッツをロック    */
  235.     GMSetGraph(&pcv->offgraph[0][pcv->depth]); /* 描画をオフライン画面に対して行う     */
  236.     pcv->offgraph[0][pcv->depth].bmap = &(*pcv->bitsH[0][pcv->depth])->bmap;
  237.     GMAPage(G_ALLPAGE);        /* カレントグラフの初期設定    */
  238.     GMBackColor(G_BLACK);
  239.     GMForeColor(G_WHITE);
  240.  
  241.     if ((dx % 8) == 0) {
  242.         size = (dx >> 3) * BUF_Y;
  243.     } else {
  244.         size = ((dx >> 3) + 1) * BUF_Y;
  245.     }
  246.  
  247.     buffer = &oneRegion.buffer;
  248.     for(y = dy / BUF_Y; y > 0; y-- ) {
  249.         read_cut(pcv, buffer, size );
  250.         cutPrint(pcv, buffer );
  251.     }
  252.     if ((amari = dy % BUF_Y) != 0) {
  253.         size = ((((dx * amari)- 1 ) >> 3 ) + 1 );
  254.         read_cut(pcv, buffer, size );
  255.         cutPrint(pcv, buffer );
  256.     }
  257.     GMSetGraph(&pcv->offgraph[pcv->cutNo[pcv->depth]][pcv->depth]); /* 描画をオフライン画面に対して行う     */
  258.     pcv->offgraph[pcv->cutNo[pcv->depth]][pcv->depth].bmap = &(*pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth])->bmap;
  259.     GMCopy(&(*pcv->bitsH[0][pcv->depth])->bmap, &(*pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth])->bmap,
  260.         &pcv->offgraph[0][pcv->depth].rect, &pcv->offgraph[pcv->cutNo[pcv->depth]][pcv->depth].rect,
  261.             G_PSET, NULL);
  262.     GMUnlockBits(pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth]);    /* オフライングラフのビッツをアンロック    */
  263.     GMUnlockBits(pcv->bitsH[0][pcv->depth]);        /* オフライングラフのビッツをアンロック    */
  264.     if (pcv->bitsH[0][pcv->depth] != NULL)
  265.         /* オフグラフ用のビッツハンドルを廃棄する */
  266.         GMDisposeBits(pcv->bitsH[0][pcv->depth]);
  267.  
  268.     /* オフライングラフが作成されていたら */
  269.     if (pcv->offgraphOK[0][pcv->depth]) {
  270.         /* ビットマップポインタだけヌルにして */
  271.         pcv->offgraph[0][pcv->depth].bmap = NULL;
  272.         /* グラフをクローズする */
  273.         GMCloseGraph(&pcv->offgraph[0][pcv->depth]);
  274.     }
  275.     return(0);
  276. }    
  277.  
  278. void    cutPrint(pcv, buffer)
  279.     ComVal *pcv;
  280.     char *buffer;
  281. {
  282.     char **buffHdl;
  283.     char *pack1;
  284.     char *pack2;
  285.     long sizep,size;
  286.     int i,j,sw;
  287.  
  288.     sizep = pcv->rc.d.right;
  289.     pcv->ymax = pcv->ymax - 16;
  290.     if (pcv->ymax < 0)
  291.         pcv->rc.d.bottom = pcv->rc.d.bottom + pcv->ymax;
  292.  
  293.     sw = sizep % 16;
  294.     if ((sw && (sw < 9))) {
  295.         if ((sizep % 8)) {
  296.             sizep = (sizep / 8) + 2;
  297.         } else {
  298.             sizep = (sizep / 8) + 1;
  299.         }    
  300.             size = (sizep * 16) + 1024;
  301.             buffHdl = MMChHdlNew(size);
  302.             MMHdlLock(buffHdl);
  303.             pack1 = buffer;
  304.             pack2 = *buffHdl;
  305.             for (j=0;j<16;j++) {
  306.                 for (i=0;i<sizep-1;i++) {
  307.                     *pack2++ = *pack1++;
  308.                 }
  309.                 *pack2++ = 0;
  310.             }
  311.             GMFillImg(*buffHdl,&(pcv->rc));
  312.             MMHdlUnlock(buffHdl);
  313.             MMHdlDispose(buffHdl);
  314.     } else {
  315.         GMFillImg(buffer,&(pcv->rc));
  316.     }
  317.     pcv->rc.d.top = pcv->rc.d.top + 16;
  318.     pcv->rc.d.bottom = pcv->rc.d.bottom + 16;
  319. }
  320.  
  321. int    expand1( org, count, cond )
  322.     BYTE2    *org;
  323.     BYTE2    *cond;
  324.     int    count;
  325. {
  326.     int    pt, bt, flag,fgg = 0;
  327.     register BYTE2    *head, *body;
  328.     if ( *cond == 1 ) {
  329.         for( pt=0; pt < count; pt++ ) *org++=0;
  330.         return( count );
  331.     }
  332.     pt = (( count-1 ) >> 3 ) + 1;
  333.  
  334.     body = ( head = cond+1 ) + pt;
  335.     for( ; pt; pt-- ) {
  336.         flag = *head++;
  337.         for( bt=8; bt; bt-- ) {
  338.             if ( flag & 0x80 )  {
  339.                 *org = *body++;
  340.             } else    *org = 0;
  341.             org++;
  342.             flag <<= 1;
  343.         }
  344.     }
  345.  
  346.     return( count );
  347. }
  348.     
  349.  
  350. int    expand2( org, count, cond )
  351.     BYTE2    *org;
  352.     BYTE2    *cond;
  353.     int    count;
  354. {
  355.     static    LINEBUF    orgBuf;
  356.     register    c;
  357.     register BYTE2    *buf;
  358.     buf = orgBuf;
  359.     if ( count == 0 )
  360.         for( c=0; c<BUF_X; c++ )
  361.             *buf++ = 0;
  362.     else
  363.         for( c=0; c < count; c++ ) {
  364.             *org = *cond++ ^ *buf;
  365.             *buf++ = *org++;
  366.         }
  367.     return( count );
  368. }
  369.  
  370. /******************************************************************************
  371.  *    offgraph():    オフグラフの作成
  372.  ******************************************************************************
  373.  *    引数:    ComVal *pcv    共通変数へのポインタ
  374.  */
  375. int offgraph(ComVal *pcv)
  376. {
  377.     int ret;
  378.     Rect rc;
  379.  
  380.     rc.d.top = 0;
  381.     rc.d.left = 0;
  382.     rc.d.bottom = pcv->y_size;
  383.     rc.d.right = pcv->x_size;
  384.  
  385.     /* オフライングラフとワークのグラフをヌルクリアする */
  386.     memset(&pcv->offgraph[pcv->cutNo[pcv->depth]][pcv->depth], 0, sizeof(Graph));
  387.  
  388.     /* オフライングラフ用ビッツを設定する（テキストモードにする） */
  389.     pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth] = GMNewBits(G_TXT, &rc, G_ALLPAGE);
  390.     if (pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth] == NULL) {
  391.         EMDeCross();
  392.         DMError(D_RED | D_CONFIRM, "cutsub.c\rメモリが確保できません。");
  393.         EMEnCross();
  394.         return FALSE;
  395.     }
  396.  
  397.     /* ビッツのビットイメージ領域をパレットNo.0でクリア */
  398.     memset((*pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth])->data, 0, (size_t)(*pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth])->size);
  399.  
  400.     /* オフライングラフ情報の作成 */
  401.     pcv->offgraph[pcv->cutNo[pcv->depth]][pcv->depth].bmap = &(*pcv->bitsH[pcv->cutNo[pcv->depth]][pcv->depth])->bmap;
  402.     ret = GMCalcGraph(&pcv->offgraph[pcv->cutNo[pcv->depth]][pcv->depth]);
  403.     if (ret != 0) {
  404.         EMDeCross();
  405.         DMError(D_RED | D_CONFIRM, "cutsub.c\rグラフが作成できません。");
  406.         EMEnCross();
  407.         return FALSE;
  408.     }
  409.     /* オフライングラフ作成完了フラグオン */
  410.     pcv->offgraphOK[pcv->cutNo[pcv->depth]][pcv->depth] = TRUE;
  411.     return TRUE;
  412. }
  413.  
  414. /******************************************************************************
  415.  *    dispoBits():    ビッツの解放
  416.  ******************************************************************************
  417.  *    引数:    ComVal *pcv    共通変数へのポインタ
  418.  */
  419. int dispoBits(ComVal *pcv)
  420. {
  421.     int ret;
  422.  
  423.     if (pcv->cutNo[pcv->depth] == 1)
  424.         return;
  425.  
  426.     for(ret=(pcv->cutNo[pcv->depth]-1);ret>0;ret--) {
  427.     
  428.         if (pcv->bitsH[ret][pcv->depth] != NULL)
  429.             /* オフグラフ用のビッツハンドルを廃棄する */
  430.             GMDisposeBits(pcv->bitsH[ret][pcv->depth]);
  431.  
  432.         /* オフライングラフが作成されていたら */
  433.         if (pcv->offgraphOK[ret][pcv->depth]) {
  434.             /* ビットマップポインタだけヌルにして */
  435.             pcv->offgraph[ret][pcv->depth].bmap = NULL;
  436.             /* グラフをクローズする */
  437.             GMCloseGraph(&pcv->offgraph[ret][pcv->depth]);
  438.         }
  439.     }
  440.     pcv->cutNo[pcv->depth] = 1;
  441. }
  442.  
  443. /******************************************************************************
  444.  *    read_cut():    カットデータハンドルから読み込み
  445.  ******************************************************************************
  446.  *    引数:    ComVal *pcv    共通変数へのポインタ
  447.  *        char *Pt
  448.  */
  449. void read_cut(ComVal *pcv, char *Pt, int Size)
  450. {
  451.     memcpy(Pt, pcv->cutPt, Size);
  452.     pcv->cutPt += Size;
  453. }
  454.  
  455. STR@1|EdEV3.00<@(!%G0JHH     
  456. ;7\7
  457. 6W^ｺﾏ Z@ "    (.Ohh$000ﾖ=STL@ﾇL